Variables

Types

Dans un programme, il nous faut des données. Ces données sont stockées dans des variables.
En Java, les variables ont obligatoirement un type. Ce n'est pas le cas dans tous les langages et c'est à la fois un énorme avantage et un inconvénient pour le développeur.

C'est quoi un type ?

C'est ce qui définit le type de contenu de la variable. Bon ok je vous donne un exemple :

int monChiffre = 12; // je n'oublie pas le point-virgule

Ici je crée une variable dont le nom est monChiffre. Le type de cette variable est int et sa valeur est 12.
int signifie integer, c'est un type qui sert à représenter les nombres entiers, qu'ils soient positifs ou négatifs.

Java a 2 sortes de types :

les 8 types primitifs (en minuscule) :
- boolean(*)
- byte
- char(*)
- short
- int(*)
- long(*)
- float
- double(*)
(*) : ces types sont importants, retenez les
les types objets (commencent par une majuscule) :
- String
- List
- Object
- ...

Il n'y a techniquement pas de limites au nombre de types objets car chacun peut créer les siens. C'est un des concepts de la programmation orientée objet mais nous y reviendront plus tard. En attendant gardez cette info dans un coin de votre gigantesque cerveau.

Pour déclarer une variable rien de plus simple : il vous suffit de choisir un type et un nom.
type nom;

Le cas de void

Java a aussi un type un peu particulier : void. Ce type (qui n'en est pas un) signifie qu'il n'y a pas de type. Il n'est pas possible de déclarer une variable de type void, cela n'aurait aucun sens. Mais vous l'avez pourtant déjà rencontré dans toutes les fois où vous avez vu un main :

void main() { }

La raison à sa présence sera abordée dans la section sur les méthodes. Patience !

Déclaration vs Initialisation

On peut déclarer une variable sans l'initialiser :

byte    a;
short   b;
int     c;
long    d;
float   e;
double  f;
char    g;
boolean h;
String  i; // type objet, commence par une majuscule

// je ne suis pas inventif sur le nom de mes variables, je sais

Initialiser signifie donner une valeur. Actuellement je n'ai donné aucune valeur à ces variables, elles ont donc toutes une valeur par défaut comme l'indique la liste ci dessous :

Type	Valeur par défaut	Utilité
`byte`	0	Très petites valeurs entières [-128, 127]
`short`	0	Petites valeurs entières [-32768, 32767]
`int`	0	Valeurs entières [-2147483648, 2147483647]
`long`	0L	Grandes valeurs entières [-9223372036854775808, 9223372036854775807]
`float`	0.0F	Nombres réels (à virgule) mais faible précision
`double`	0.0	Nombres réels (à virgule) avec double précision
`char`	'\u0000'	Charactères (ex : 'A', 'b', '\n')
`boolean`	`false`	Vrai (`true`) ou faux (`false`)
`String`	`null`	Chaine de caractères (texte)

Ok, ça fait beaucoup d'informations mais à quoi ça sert concrètement ?

En fait, un type sert à préciser la nature de la donnée. Si la donnée est un nombre entier (sans virgule), on peut utiliser les types byte, short, int ou encore long.
Leur différence relève principalement dans leur capacité à représenter de plus ou moins grands nombres. Par exemple, la valeur maximale d'un byte est 127, sa valeur minimale est -128.

Ce sera au développeur de choisir le type qui convient le mieux à ses usages.

L'initialisation d'une variable consiste à lui donner une valeur. On fait ça avec l'opérateur =.

int a; // a est déclarée et vaut 0 par défaut

a = 6; // a est initialisée et vaut 6

Les types primitifs (qui commencent par une minuscule) les plus couramment utilisés sont int, long, double, boolean et char. Les autres sont assez peu utilisés en pratique mais vous pourriez être amenés à les rencontrer en lisant du code sur internet.

Pour simplifier les choses, on peut déclarer des variables et leur assigner une valeur en un seul coup :

int a = 6;

Les valeurs littérales

Vous l'aurez remarqué, dans la section des valeurs par défaut, certaines valeurs ont des notations curieuses. En fait pour initialiser certains types de variables il faut une notation un peu spéciale.

Au même titre que pour initialiser un int on note sa valeur 3. Pour initialiser un long il faut préciser à l'ordinateur que ce n'est pas un int dans l'écriture de sa valeur. On rajoute donc un symbole pour que la machine ne confonde pas les deux : L. Donc si je veux écrire la valeur littérale d'un long qui vaut 3, il faudra écrire 3L.

C'est la même chose avec le type float qui ne doit pas être confondu avec double. Comme le type double est plus couramment utilisé, on doit préciser quand il s'agit d'un float avec un F à la fin de la valeur : 3.141592F.

Pour les valeurs littérales de char, on note la valeur entre guillemets simples : 'a'.

char a = 'A';
char b = '?';
char c = 'Hello'; // ne marche pas

Rappel : char permet de stocker un seul caractère, une lettre est un caractère, la ponctuation aussi

Pour les valeurs littérales de String, on note la valeur entre guillemets : "Bonjour !".

String a = "Bonjour !";

L'inférence de type

Le compilateur de Java est capable de prouesses pour aider à rendre le développement plus simple ! Il est capable de deviner le type d'une variable si on lui demande de le faire !
Comment on s'y prend ? Avec un nouveau mot clé : var. Si au lieu de déclarer le type de la variable j'utilise var, le compilateur va se débrouiller pour deviner de quoi il s'agit :

var a = "Bonjour !"; // a est de type String
var b = 34;          // b est de type int
var c = 34L;         // c est de type long

C'est très pratique quand on veut gagner du temps sans avoir besoin de réfléchir au meilleur type à utiliser, le compilateur s'en charge pour vous !
Ça pose cependant un souci pour la lecture de code car si vous ne savez pas quel type le compilateur a assigné à votre variable. Heureusement les IDE sont malins et vous indiquent le type des variables déclarées avec var :

Pasted image 20250407112912.png

Maintenant qu'on a des variables, on va pouvoir les manipuler avec des 8. Opérateurs !